/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package bombercloud.client;

import bombercloud.commons.BlocoFixo;
import bombercloud.commons.BlocoQuebra;
import bombercloud.commons.Bomba;
import bombercloud.commons.Boneco;
import bombercloud.commons.Mapa;
import bombercloud.commons.Request;
import bombercloud.commons.Response;
import java.awt.Color;
import java.awt.Component;
import java.awt.HeadlessException;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

/**
 *
 * @author Leonardo Oliveira Moreira
 */
public class BomberCloudUI extends JFrame implements WindowListener, KeyListener {

    JLabel JLabelBonecoBranco, JLabelBonecoPreto, JLabelBonecoAzul, JLabelBonecoVermelho, JLabelBonecoVerde, jLabelBonecoPlacarBranco, jLabelBonecoPlacarPreto, jLabelBonecoPlacarAzul,
            jLabelBonecoPlacarVermelho, jLabelBonecoPlacarVerde, jLabelFogo;
    JPanel mainPanel;
    JLabel jLabelBlFixo;
    JLabel jLabelBlQuebra;
    JLabel jLabelBomba;
    Timer tempo;
    private ArrayList<Bomba> listBombas;
    ArrayList<BlocoQuebra> listDLugaresPossiveis;
    ArrayList<BlocoQuebra> listDLugaresNLivres;
    private ArrayList<BlocoQuebra> listLinhaDeFogo;
    private ArrayList<BlocoFixo> listParedes;
    private ArrayList<Boneco> listBonecos;
    private Socket socket;
    private ObjectInputStream inputStream;
    private ObjectOutputStream outputStream;
    Boneco boneco;
    Boneco bonecoPlacar;
    boolean prossegue;
    Mapa mapa;
    String usuarioPC;
    ThreadClient t;

    public BomberCloudUI(Socket socket1, ObjectOutputStream objectOutputStream, ObjectInputStream inputStream1, Boneco bonecoEsconhido, Mapa m, String usuario, ThreadClient t) throws HeadlessException {
        this.t = t;
        setSize(740, 655);
        setLocationRelativeTo(null);
        setLayout(null);
        setResizable(false);
        this.setTitle("Player: " + bonecoEsconhido.getNumero());

        mainPanel = (JPanel) this.getContentPane();
        mainPanel.setBackground(Color.decode("#004000"));

        socket = socket1;
        outputStream = objectOutputStream;
        inputStream = inputStream1;
        boneco = bonecoEsconhido;
        mapa = m;
        usuarioPC = usuario;

        criacaoDoTabuleiro(mainPanel);

        this.addKeyListener(this);
        eventos();
    }

    //ao iniciar a classe, cria o tabuleiro fazendo requisições ao servidor de onde estão os objetos.
    public void criacaoDoTabuleiro(JPanel mainPanel) {
        listLinhaDeFogo = mapa.getListLinhaDeFogo();

        listParedes = mapa.getListParedes();

        //Costrução das paredes
        for (BlocoFixo bf : listParedes) {
            jLabelBlFixo = new JLabel(new ImageIcon(bf.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
            jLabelBlFixo.setLayout(null);
            jLabelBlFixo.setSize(48, 40);
            jLabelBlFixo.setLocation(bf.getX(), bf.getY());
            mainPanel.add(jLabelBlFixo);
        }

        listDLugaresNLivres = mapa.getListLugaresNLivres();

        //Colocação dos blocos que quebram
        for (BlocoQuebra bq : listDLugaresNLivres) {
            jLabelBlQuebra = new JLabel(new ImageIcon(bq.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
            jLabelBlQuebra.setLayout(null);
            jLabelBlQuebra.setSize(48, 40);
            jLabelBlQuebra.setLocation(bq.getX(), bq.getY());
            jLabelBlQuebra.setName("BLOCO_QUEBRA");
            mainPanel.add(jLabelBlQuebra);
        }



        bonecoPlacar = new Boneco();
        listBonecos = mapa.getListBonecos();

// <editor-fold defaultstate="collapsed" desc="// COLOCA BONECOS DO PLACAR-----------------------">

        jLabelBonecoPlacarBranco = new JLabel(new ImageIcon(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "BRANCO_FOTO.png"));
        jLabelBonecoPlacarBranco.setLayout(null);
        jLabelBonecoPlacarBranco.setSize(48, 40);
        jLabelBonecoPlacarBranco.setLocation(480, 60);
        jLabelBonecoPlacarBranco.setName("BONECO_BRANCO_PLACAR");
        jLabelBonecoPlacarBranco.setEnabled(false);
        mainPanel.add(jLabelBonecoPlacarBranco);

        jLabelBonecoPlacarPreto = new JLabel(new ImageIcon(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "PRETO_FOTO.png"));
        jLabelBonecoPlacarPreto.setLayout(null);
        jLabelBonecoPlacarPreto.setSize(48, 40);
        jLabelBonecoPlacarPreto.setLocation(530, 60);
        jLabelBonecoPlacarPreto.setName("BONECO_PRETO_PLACAR");
        jLabelBonecoPlacarPreto.setEnabled(false);
        mainPanel.add(jLabelBonecoPlacarPreto);

        jLabelBonecoPlacarAzul = new JLabel(new ImageIcon(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "AZUL_FOTO.png"));
        jLabelBonecoPlacarAzul.setLayout(null);
        jLabelBonecoPlacarAzul.setSize(48, 40);
        jLabelBonecoPlacarAzul.setLocation(580, 60);
        jLabelBonecoPlacarAzul.setName("BONECO_AZUL_PLACAR");
        jLabelBonecoPlacarAzul.setEnabled(false);
        mainPanel.add(jLabelBonecoPlacarAzul);

        jLabelBonecoPlacarVermelho = new JLabel(new ImageIcon(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "VERMELHO_FOTO.png"));
        jLabelBonecoPlacarVermelho.setLayout(null);
        jLabelBonecoPlacarVermelho.setSize(48, 40);
        jLabelBonecoPlacarVermelho.setLocation(630, 60);
        jLabelBonecoPlacarVermelho.setName("BONECO_BRANCO_PLACAR");
        jLabelBonecoPlacarVermelho.setEnabled(false);
        mainPanel.add(jLabelBonecoPlacarVermelho);

        jLabelBonecoPlacarVerde = new JLabel(new ImageIcon(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "VERDE_FOTO.png"));
        jLabelBonecoPlacarVerde.setLayout(null);
        jLabelBonecoPlacarVerde.setSize(48, 40);
        jLabelBonecoPlacarVerde.setLocation(680, 60);
        jLabelBonecoPlacarVerde.setName("BONECO_VERDE_PLACAR");
        jLabelBonecoPlacarVerde.setEnabled(false);
        mainPanel.add(jLabelBonecoPlacarVerde);

        for (Boneco b : listBonecos) {
            switch (b.getNumero()) {
                case 1: {
                    b.setBoneco(jLabelBonecoPlacarBranco);
                    jLabelBonecoPlacarBranco.setEnabled(true);
                    if (boneco.getNumero() == 1) {
                        bonecoPlacar.setBoneco(jLabelBonecoPlacarBranco);
                    }
                    break;
                }
                case 2: {
                    b.setBoneco(jLabelBonecoPlacarPreto);
                    jLabelBonecoPlacarPreto.setEnabled(true);
                    if (boneco.getNumero() == 2) {
                        bonecoPlacar.setBoneco(jLabelBonecoPlacarPreto);
                    }
                    break;
                }
                case 3: {
                    b.setBoneco(jLabelBonecoPlacarAzul);
                    jLabelBonecoPlacarAzul.setEnabled(true);
                    if (boneco.getNumero() == 3) {
                        bonecoPlacar.setBoneco(jLabelBonecoPlacarAzul);
                    }
                    break;
                }
                case 4: {
                    b.setBoneco(jLabelBonecoPlacarVermelho);
                    jLabelBonecoPlacarVermelho.setEnabled(true);
                    if (boneco.getNumero() == 4) {
                        bonecoPlacar.setBoneco(jLabelBonecoPlacarVermelho);
                    }
                    break;
                }
                case 5: {
                    b.setBoneco(jLabelBonecoPlacarVerde);
                    jLabelBonecoPlacarVerde.setEnabled(true);
                    if (boneco.getNumero() == 5) {
                        bonecoPlacar.setBoneco(jLabelBonecoPlacarVerde);
                    }
                    break;
                }
            }
        }
        // </editor-fold> 

        colocaBonecos();
    }

    public void colocaBonecos() {
        for (Boneco b : listBonecos) {
            switch (b.getNumero()) {
                case 1: {
                    JLabelBonecoBranco = new JLabel(new ImageIcon(b.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
                    JLabelBonecoBranco.setLayout(null);
                    JLabelBonecoBranco.setSize(48, 40);
                    JLabelBonecoBranco.setLocation(b.getX(), b.getY());
                    JLabelBonecoBranco.setName("BONECO");
                    b.setBoneco(JLabelBonecoBranco);
                    break;
                }
                case 2: {
                    JLabelBonecoPreto = new JLabel(new ImageIcon(b.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
                    JLabelBonecoPreto.setLayout(null);
                    JLabelBonecoPreto.setSize(48, 40);
                    JLabelBonecoPreto.setLocation(b.getX(), b.getY());
                    JLabelBonecoPreto.setName("BONECO");
                    b.setBoneco(JLabelBonecoPreto);
                    break;
                }
                case 3: {
                    JLabelBonecoAzul = new JLabel(new ImageIcon(b.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
                    JLabelBonecoAzul.setLayout(null);
                    JLabelBonecoAzul.setSize(48, 40);
                    JLabelBonecoAzul.setLocation(b.getX(), b.getY());
                    JLabelBonecoAzul.setName("BONECO");
                    b.setBoneco(JLabelBonecoAzul);
                    break;
                }
                case 4: {
                    JLabelBonecoVermelho = new JLabel(new ImageIcon(b.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
                    JLabelBonecoVermelho.setLayout(null);
                    JLabelBonecoVermelho.setSize(48, 40);
                    JLabelBonecoVermelho.setLocation(b.getX(), b.getY());
                    JLabelBonecoVermelho.setName("BONECO");
                    b.setBoneco(JLabelBonecoVermelho);
                    break;
                }
                case 5: {
                    JLabelBonecoVerde = new JLabel(new ImageIcon(b.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
                    JLabelBonecoVerde.setLayout(null);
                    JLabelBonecoVerde.setSize(48, 40);
                    JLabelBonecoVerde.setLocation(b.getX(), b.getY());
                    JLabelBonecoVerde.setName("BONECO");
                    b.setBoneco(JLabelBonecoVerde);
                    break;
                }
            }
        }

        //colocar os JLabelBoneco
        for (Boneco b : listBonecos) {
            if (b.getNumero() != boneco.getNumero()) {
                mainPanel.add(b.getBoneco());
            }
        }
        //colocar o JLabelBoneco que será controlado
        for (Boneco b : listBonecos) {
            if (b.getNumero() == boneco.getNumero()) {
                mainPanel.add(b.getBoneco());
                boneco.setBoneco(b.getBoneco());
            }
        }
    }

    //método que atualiza o tabuleiro após alguma alteração. recebe o mapa para 
    //atualizar as novas listas que estão no servidor
    public void atualizacaoMapa(Mapa mapa) {

        for (Boneco b : listBonecos) {
            mainPanel.remove(b.getBoneco());
        }

        //atualiza as listas com o mapa enviado pelo servidor
        listDLugaresNLivres = mapa.getListLugaresNLivres();
        listBonecos = mapa.getListBonecos();
        listParedes = mapa.getListParedes();
        listBombas = mapa.getListBombas();
        listDLugaresPossiveis = mapa.getListLugaresPossiveis();

        colocaBonecos();

//        System.out.println(listBombas.size());
        if (listBombas != null) {
            for (Bomba b : listBombas) {
                jLabelBomba = new JLabel(new ImageIcon(b.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
                jLabelBomba.setLayout(null);
                jLabelBomba.setSize(48, 40);
                jLabelBomba.setLocation(b.getX(), b.getY());
                jLabelBomba.setName("BOMBA");
                mainPanel.add(jLabelBomba);
            }
        }
        mainPanel.repaint();
    }

    //move o booneco para a nova possição
    public void bonecoMovimento(Boneco bon) {
        if (bon != null) {
            for (Boneco b : listBonecos) {
                if (b.getNumero() == bon.getNumero()) {
                    if (boneco.getNumero() == b.getNumero()) {
                        b.getBoneco().setLocation(bon.getX(), bon.getY());
                    }
                    b.getBoneco().setLocation(bon.getX(), bon.getY());
                    b.setX(bon.getX());
                    b.setY(bon.getY());
                }
            }
            mainPanel.repaint();
        }
    }
    //Evento do botão pressionado, com colisão nas paredes laterais.

    @Override
    public void keyPressed(KeyEvent e) {
        int x, y;
        x = boneco.getBoneco().getX();
        y = boneco.getBoneco().getY();

        // <editor-fold defaultstate="collapsed" desc="// MOVIMENTAÇÃO------------------------">
        if (e.getKeyCode() == e.VK_LEFT) {
            boneco.getBoneco().setIcon(new ImageIcon(boneco.getImagemESQUERDA().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
            x = x - 7;
            //condição é para saber se o boneco está na posição correta de um "corredor".
            boolean condicao = ((y == 140) || (y == 220) || (y == 300) || (y == 380) || (y == 460) || (y == 540));
            if (x > 48 && condicao) {
                boolean livre = true;
                //for para verificar se tem algum bloco quebra no caminho.

//                try {
//                    Class.forName("org.postgresql.Driver");
//                    Connection connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/bomberCloud", "postgres", "postgres");
//                    Statement stmt = connection.createStatement();
//                    ResultSet rs = stmt.executeQuery("select * from caminho_livre WHERE x = " + (x - 42) + " AND y = " + y  + ";");
//                    if (rs.next() && rs != null) {
//                        livre = true;
//                        System.out.println("Livre para a esquerda");
//                    }
//                    stmt.close();
//                    connection.close();
//                } catch (SQLException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                } catch (ClassNotFoundException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                }

                for (BlocoQuebra b : listDLugaresNLivres) {
                    if (b.getX() == (x - 42) && b.getY() == y) {
                        livre = false;
                    }
                }
                if (livre) {
                    //muda a posição do boneco
//                    boneco.getBoneco().setLocation(x, y);
                    //diz ao servidor que o boneco se mexeu, manda a nova posiçao para que seja atualizada no servidor.
                    Request request = new Request();
                    request.setType(Request.REQUEST_TYPE_MOVIMENT);
                    request.setParam1(x);
                    request.setParam2(y);
                    request.setParam3(boneco);
                    executeRequest(request);
                }
            }
        }
        if (e.getKeyCode() == e.VK_RIGHT) {
            boneco.getBoneco().setIcon(new ImageIcon(boneco.getImagemDIREITA().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
            x = x + 7;
            //condição é para saber se o boneco está na posição correta de um "corredor".
            boolean condicao = ((y == 140) || (y == 220) || (y == 300) || (y == 380) || (y == 460) || (y == 540));
            if (x <= 637 && condicao) {
                boolean livre = true;
                //for para verificar se tem algum bloco quebra no caminho.
                
//                try {
//                    Class.forName("org.postgresql.Driver");
//                    Connection connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/bomberCloud", "postgres", "postgres");
//                    Statement stmt = connection.createStatement();
//                    ResultSet rs = stmt.executeQuery("select * from caminho_livre WHERE x = " + (x + 42) + " AND y = " + y  + ";");
//                    if (rs.next() && rs != null) {
//                        livre = true;
//                        System.out.println("Livre para a direita");
//                    }
//                    stmt.close();
//                    connection.close();
//                } catch (SQLException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                } catch (ClassNotFoundException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                }
                
                for (BlocoQuebra b : listDLugaresNLivres) {
                    if (b.getX() == (x + 42) && b.getY() == y) {
                        livre = false;
                    }
                }
                if (livre) {
                    //muda a posição do boneco
//                    boneco.getBoneco().setLocation(x, y);
                    //diz ao servidor que o boneco se mexeu, manda a nova posiçao para que seja atualizada no servidor.
                    Request request = new Request();
                    request.setType(Request.REQUEST_TYPE_MOVIMENT);
                    request.setParam1(x);
                    request.setParam2(y);
                    request.setParam3(boneco);
                    executeRequest(request);
                }
            }
        }
        if (e.getKeyCode() == e.VK_UP) {
            boneco.getBoneco().setIcon(new ImageIcon(boneco.getImagemCIMA().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
            y = y - 5;
            //condição é para saber se o boneco está na posição correta de um "corredor".
            boolean condicao = ((x == 49) || (x == 147) || (x == 245) || (x == 343) || (x == 441) || (x == 539) || (x == 637));
            if (y >= 140 && condicao) {
                boolean livre = true;
                //for para verificar se tem algum bloco quebra no caminho.
//                try {
//                    Class.forName("org.postgresql.Driver");
//                    Connection connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/bomberCloud", "postgres", "postgres");
//                    Statement stmt = connection.createStatement();
//                    ResultSet rs = stmt.executeQuery("select * from caminho_livre WHERE x = " + x + " AND y = " + (y - 35) + ";");
//                    if (rs.next() && rs != null) {
//                        livre = true;
//                        System.out.println("Livre para a cima");
//                    }
//                    stmt.close();
//                    connection.close();
//                } catch (SQLException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                } catch (ClassNotFoundException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                }

                for (BlocoQuebra b : listDLugaresNLivres) {
                    if (b.getX() == x && b.getY() == (y - 35)) {
                        livre = false;
                    }
                }
                if (livre) {
                    //muda a posição do boneco
//                    boneco.getBoneco().setLocation(x, y);
                    //diz ao servidor que o boneco se mexeu, manda a nova posiçao para que seja atualizada no servidor.
                    Request request = new Request();
                    request.setType(Request.REQUEST_TYPE_MOVIMENT);
                    request.setParam1(x);
                    request.setParam2(y);
                    request.setParam3(boneco);
                    executeRequest(request);

                }
            }
        }
        if (e.getKeyCode() == e.VK_DOWN) {
            boneco.getBoneco().setIcon(new ImageIcon(boneco.getImagemBAIXO().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
            y = y + 5;
            //condição é para saber se o boneco está na posição correta de um "corredor".
            boolean condicao = ((x == 49) || (x == 147) || (x == 245) || (x == 343) || (x == 441) || (x == 539) || (x == 637));
            if (y <= 540 && condicao) {
                boolean livre = true;
                //for para verificar se tem algum bloco quebra no caminho.

//                try {
//                    Class.forName("org.postgresql.Driver");
//                    Connection connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/bomberCloud", "postgres", "postgres");
//                    Statement stmt = connection.createStatement();
//                    System.out.println("select * from caminho_livre WHERE x = " + x + " y = " + (y + 35) + ";");
//                    ResultSet rs = stmt.executeQuery("select * from caminho_livre WHERE x = " + x + " AND y = " + (y + 35) + ";");
//                    if (rs.next() && rs != null) {
//                        livre = true;
//                        System.out.println("Livre para a baixo");
//                    }
//                    stmt.close();
//                    connection.close();
//                } catch (SQLException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                } catch (ClassNotFoundException ex) {
//                    JOptionPane.showMessageDialog(null, ex.getMessage());
//                }

                for (BlocoQuebra b : listDLugaresNLivres) {
                    if (b.getX() == x && b.getY() == (y + 35)) {
                        livre = false;
                    }
                }
                if (livre) {
                    //muda a posição do boneco
//                    boneco.getBoneco().setLocation(x, y);
                    //diz ao servidor que o boneco se mexeu, manda a nova posiçao para que seja atualizada no servidor.
                    Request request = new Request();
                    request.setType(Request.REQUEST_TYPE_MOVIMENT);
                    request.setParam1(x);
                    request.setParam2(y);
                    request.setParam3(boneco);
                    executeRequest(request);
                }
            }
        }
        // </editor-fold>

        // <editor-fold defaultstate="collapsed" desc="// COLOCA BOMBA NO TABULEIRO E QUEBRA OS BLOCOS------------------------">
        if (e.getKeyCode() == e.VK_A) {
            boolean condicao = (((x == 49) || (x == 98) || (x == 147) || (x == 196) || (x == 245) || (x == 294) || (x == 343) || (x == 392) || (x == 441) || (x == 490) || (x == 539) || (x == 588) || (x == 637))
                    && ((y == 140) || (y == 180) || (y == 220) || (y == 260) || (y == 300) || (y == 340) || (y == 380) || (y == 420) || (y == 460) || (y == 500) || (y == 540)));
            if (condicao) {
                jLabelBomba = new JLabel(new ImageIcon(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "Bomba.gif"));
                jLabelBomba.setLayout(null);
                jLabelBomba.setSize(48, 40);
                jLabelBomba.setLocation(x, y);
                jLabelBomba.setName("BOMBA");
                mainPanel.add(jLabelBomba);
                //faz a bomba colidir com o JLabelBoneco como se fosse um bloco
                BlocoQuebra b = new BlocoQuebra();
                b.setjLabelFogo(jLabelBomba);
                b.setX(x);
                b.setY(y);
                b.setBomba(true);
                listDLugaresNLivres.add(b);
//                 ArrayList<BlocoFixo> listaParede = new ArrayList<BlocoFixo>();
                try {
                    Class.forName("org.postgresql.Driver");
                    Connection connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/bomberCloud", "postgres", "postgres");
                    Statement stmt = connection.createStatement();
                    stmt.execute("INSERT INTO bomba (x, y) VALUES (" + b.getX() + ", " + b.getY() + ");");
                    stmt.close();
                    connection.close();
                } catch (SQLException ex) {
                    JOptionPane.showMessageDialog(null, ex.getMessage());
                } catch (ClassNotFoundException ex) {
                    JOptionPane.showMessageDialog(null, ex.getMessage());
                }
                ThreadBomba tb = new ThreadBomba(socket, outputStream, b);
                tb.start();
                Request request = new Request();
                request.setType(request.REQUEST_TYPE_CREATE_BOMBA);
                request.setParam1(x);
                request.setParam2(y);
                request.setParam3(jLabelBomba);
                request.setParam4(listDLugaresNLivres);
                executeRequest(request);

                //fim da ideia
            }
        }
        // </editor-fold>
    }

    public void explosao(BlocoQuebra bomba) {
        if (bomba != null) {

            //lista para coletar os blocos que a bomba explodirá
            ArrayList<BlocoQuebra> blocosARemover = new ArrayList<BlocoQuebra>();

            //testadores para os for
            Parede achouBloco;
            Parede achouPareide;

            //lista para saber se alguma parede foi encontrada proximo a bomba
            ArrayList<Parede> paredesEncontradas = new ArrayList<Parede>();
            ArrayList<Parede> blocosEncontrados = new ArrayList<Parede>();

            // <editor-fold defaultstate="collapsed" desc="// ENCONTRA AS PAREDES PRÓXIMOS À BOMBA------------------------">

            boolean paredeDireita = false;
            boolean paredeEsquerda = false;
            boolean paredeCima = false;
            boolean paredeBaixo = false;

            for (int nivel = 1; nivel < 5; nivel++) {
                int pxX = nivel * 49;
                int pxY = nivel * 40;

                for (BlocoFixo parede : listParedes) {
                    //baixo
                    if ((parede.getX() == bomba.getX()) && (parede.getY() == (bomba.getY() + pxY))) {
                        //verifica se a parede é a baixo
                        if (!paredeBaixo) {
                            //achou bloco a baixo
                            paredeBaixo = true;
                            achouPareide = new Parede();
                            achouPareide.setBaixo(true);
                            achouPareide.setBlocoFixo(parede);
                            paredesEncontradas.add(achouPareide);
                        }
                    }

                    //cima
                    if ((parede.getX() == bomba.getX()) && (parede.getY() == (bomba.getY() - pxY))) {
                        if (!paredeCima) {
                            //achou bloco a cima
                            paredeCima = true;
                            achouPareide = new Parede();
                            achouPareide.setCima(true);
                            achouPareide.setBlocoFixo(parede);
                            paredesEncontradas.add(achouPareide);
                        }
                    }

                    //direita
                    if ((parede.getX() == (bomba.getX() + pxX)) && (parede.getY() == bomba.getY())) {
                        if (!paredeDireita) {
                            //achou bloco a direita
                            paredeDireita = true;
                            achouPareide = new Parede();
                            achouPareide.setDireita(true);
                            achouPareide.setBlocoFixo(parede);
                            paredesEncontradas.add(achouPareide);
                        }
                    }

                    //esquerda
                    if ((parede.getX() == (bomba.getX() - pxX)) && (parede.getY() == bomba.getY())) {
                        if (!paredeEsquerda) {
                            //achou bloco a esquerda
                            paredeEsquerda = true;
                            achouPareide = new Parede();
                            achouPareide.setEsquerda(true);
                            achouPareide.setBlocoFixo(parede);
                            paredesEncontradas.add(achouPareide);
                        }
                    }

                }
            }

            // </editor-fold>

            // <editor-fold defaultstate="collapsed" desc="// ENCONTRA OS BLOCOS PRÓXIMOS À BOMBA------------------------">

            boolean blocoDireita = false;
            boolean blocoEsquerda = false;
            boolean blocoCima = false;
            boolean blocoBaixo = false;

            Parede paredeAux = null;

            for (int nivel = 1; nivel < 5; nivel++) {
                int pxX = nivel * 49;
                int pxY = nivel * 40;
                for (BlocoQuebra bloco : listDLugaresNLivres) {
                    //verifica se tem bloco proximo a bomba a baixo
                    if ((bloco.getX() == bomba.getX()) && (bloco.getY() == (bomba.getY() + pxY))) {
                        //verifica se exite parede 
                        if (paredesEncontradas.size() > 0) {
                            //percorre as paredes encontradas
                            for (Parede parede : paredesEncontradas) {
                                if (parede.isBaixo()) {
                                    paredeAux = parede;
                                }
                            }
                            //vreifica se existe parede a baixo
                            if (paredeAux != null) {
                                //verifica se a parede esta mais a baixo
                                if (paredeAux.getBlocoFixo().getY() > (bomba.getY() + pxY)) {
                                    if (!blocoBaixo) {
                                        blocoBaixo = true;
                                        achouBloco = new Parede();
                                        achouBloco.setBaixo(true);
                                        achouBloco.setBlocoQuebra(bloco);
                                        blocosEncontrados.add(achouBloco);
                                        blocosARemover.add(bloco);
                                    }
                                } else {
                                    blocoBaixo = true;
                                }
                                //nao tem parede a baixo
                            } else {
                                if (!blocoBaixo) {
                                    blocoBaixo = true;
                                    achouBloco = new Parede();
                                    achouBloco.setBaixo(true);
                                    achouBloco.setBlocoQuebra(bloco);
                                    blocosEncontrados.add(achouBloco);
                                    blocosARemover.add(bloco);
                                }
                            }
                            //nao achou parede a baixo
                        } else {
                            if (!blocoBaixo) {
                                blocoBaixo = true;
                                achouBloco = new Parede();
                                achouBloco.setBaixo(true);
                                achouBloco.setBlocoQuebra(bloco);
                                blocosEncontrados.add(achouBloco);
                                blocosARemover.add(bloco);
                            }

                        }
                    }


                    //verifica se tem bloco proximo a bomba a cima
                    if ((bloco.getX() == bomba.getX()) && (bloco.getY() == (bomba.getY() - pxY))) {
                        //verifica se exite parede 
                        if (paredesEncontradas.size() > 0) {
                            //percorre as paredes encontradas
                            for (Parede parede : paredesEncontradas) {
                                if (parede.isCima()) {
                                    paredeAux = parede;
                                }
                            }
                            //vreifica se existe parede a cima
                            if (paredeAux != null) {
                                //verifica se a parede esta mais a cima
                                if (paredeAux.getBlocoFixo().getY() < (bomba.getY() - pxY)) {
                                    if (!blocoCima) {
                                        blocoCima = true;
                                        achouBloco = new Parede();
                                        achouBloco.setCima(true);
                                        achouBloco.setBlocoQuebra(bloco);
                                        blocosEncontrados.add(achouBloco);
                                        blocosARemover.add(bloco);
                                    }
                                } else {
                                    blocoCima = true;
                                }
                                //nao tem parede a cima
                            } else {
                                if (!blocoCima) {
                                    blocoCima = true;
                                    achouBloco = new Parede();
                                    achouBloco.setCima(true);
                                    achouBloco.setBlocoQuebra(bloco);
                                    blocosEncontrados.add(achouBloco);
                                    blocosARemover.add(bloco);
                                }
                            }
                            //nao achou parede a cima
                        } else {
                            if (!blocoCima) {
                                blocoCima = true;
                                achouBloco = new Parede();
                                achouBloco.setCima(true);
                                achouBloco.setBlocoQuebra(bloco);
                                blocosEncontrados.add(achouBloco);
                                blocosARemover.add(bloco);
                            }

                        }
                    }

                    //verifica se tem bloco proximo a bomba a direita
                    if ((bloco.getX() == (bomba.getX() + pxX)) && (bloco.getY() == bomba.getY())) {
                        //verifica se exite parede 
                        if (paredesEncontradas.size() > 0) {
                            //percorre as paredes encontradas
                            for (Parede parede : paredesEncontradas) {
                                if (parede.isDireita()) {
                                    paredeAux = parede;
                                }
                            }
                            //vreifica se existe parede a direita
                            if (paredeAux != null) {
                                //verifica se a parede esta mais a direita
                                if (paredeAux.getBlocoFixo().getX() > (bomba.getX() + pxX)) {
                                    if (!blocoDireita) {
                                        blocoDireita = true;
                                        achouBloco = new Parede();
                                        achouBloco.setDireita(true);
                                        achouBloco.setBlocoQuebra(bloco);
                                        blocosEncontrados.add(achouBloco);
                                        blocosARemover.add(bloco);
                                    }
                                } else {
                                    blocoDireita = true;
                                }
                                //nao tem parede a direita
                            } else {
                                if (!blocoDireita) {
                                    blocoDireita = true;
                                    achouBloco = new Parede();
                                    achouBloco.setDireita(true);
                                    achouBloco.setBlocoQuebra(bloco);
                                    blocosEncontrados.add(achouBloco);
                                    blocosARemover.add(bloco);
                                }
                            }
                            //nao achou parede a direita
                        } else {
                            if (!blocoDireita) {
                                blocoDireita = true;
                                achouBloco = new Parede();
                                achouBloco.setDireita(true);
                                achouBloco.setBlocoQuebra(bloco);
                                blocosEncontrados.add(achouBloco);
                                blocosARemover.add(bloco);
                            }

                        }
                    }

                    //verifica se tem bloco proximo a bomba a esquerda
                    if ((bloco.getX() == (bomba.getX() - pxX)) && (bloco.getY() == bomba.getY())) {
                        //verifica se exite parede 
                        if (paredesEncontradas.size() > 0) {
                            //percorre as paredes encontradas
                            for (Parede parede : paredesEncontradas) {
                                if (parede.isEsquerda()) {
                                    paredeAux = parede;
                                }
                            }
                            //vreifica se existe parede a esquerda
                            if (paredeAux != null) {
                                //verifica se a parede esta mais a esquerda
                                if (paredeAux.getBlocoFixo().getX() < (bomba.getX() - pxX)) {
                                    if (!blocoEsquerda) {
                                        blocoEsquerda = true;
                                        achouBloco = new Parede();
                                        achouBloco.setEsquerda(true);
                                        achouBloco.setBlocoQuebra(bloco);
                                        blocosEncontrados.add(achouBloco);
                                        blocosARemover.add(bloco);
                                    }
                                } else {
                                    blocoEsquerda = true;
                                }
                                //nao tem parede a esquerda
                            } else {
                                if (!blocoEsquerda) {
                                    blocoEsquerda = true;
                                    achouBloco = new Parede();
                                    achouBloco.setEsquerda(true);
                                    achouBloco.setBlocoQuebra(bloco);
                                    blocosEncontrados.add(achouBloco);
                                    blocosARemover.add(bloco);
                                }
                            }
                            //nao achou parede a esquerda
                        } else {
                            if (!blocoEsquerda) {
                                blocoEsquerda = true;
                                achouBloco = new Parede();
                                achouBloco.setEsquerda(true);
                                achouBloco.setBlocoQuebra(bloco);
                                blocosEncontrados.add(achouBloco);
                                blocosARemover.add(bloco);
                            }

                        }
                    }



                    //remove a bomba do tabuleiro
                    Component c2 = mainPanel.getComponentAt(bomba.getX(), bomba.getY());
                    if (c2 != null && c2.getName() != null) {
                        if (c2.getName().equalsIgnoreCase("BOMBA")) {
                            mainPanel.remove(c2);
                            mainPanel.repaint();
                        }
                    }
                }

                // </editor-fold>
            }
            //remove blocos do tabuleiro
            for (BlocoQuebra b : blocosARemover) {
                Component c = mainPanel.getComponentAt(b.getX(), b.getY());
                if (c.getName() != null) {
                    if (c.getName().equalsIgnoreCase("BLOCO_QUEBRA")) {
                        mainPanel.remove(c);
                    }
                }
            }
            //cloca fogo
            ArrayList<BlocoQuebra> Listfogo = colocaFogo(bomba, paredesEncontradas, blocosEncontrados);

            ThreadFogo tf = new ThreadFogo(socket, outputStream, bomba, blocosARemover, Listfogo, mainPanel);
            tf.start();

//        remover a blocos do tabuleiro
            if (blocosARemover != null && blocosARemover.size() > 0) {
                Request request = new Request();
                request.setType(request.REQUEST_TYPE_DELETE_BLOCOS);
                request.setParam3(blocosARemover);
                executeRequest(request);
                mainPanel.repaint();
            }

            mataBoneco(bomba);
        }
    }

    public void removeFogo(ArrayList<BlocoQuebra> Listfogo) {
        if (Listfogo.size() > 0 && Listfogo != null) {
            for (BlocoQuebra b : Listfogo) {
                Component c = mainPanel.getComponentAt(b.getX(), b.getY());
                if (c != null && c.getName() != null) {
                    if (c.getName().equalsIgnoreCase("FOGO")) {
                        mainPanel.remove(c);
                    }
                    if (c.getName().equalsIgnoreCase("BOMBA")) {
                        mainPanel.remove(c);
                    }
                }
                while (true) {
                    c = mainPanel.getComponentAt(b.getX(), b.getY());
                    if (c == null) {
                        break;
                    }
                    boolean achouAlgo = false;
                    if (c != null && c.getName() != null) {
                        if (c.getName().equalsIgnoreCase("FOGO")) {
                            mainPanel.remove(c);
                            achouAlgo = true;
                        }
                        if (c.getName().equalsIgnoreCase("BOMBA")) {
                            mainPanel.remove(c);
                            achouAlgo = true;
                        }
                        if (c.getName().equalsIgnoreCase("BONECO")) {
                            break;
                        }
                    }
                    if (!achouAlgo) {
                        break;
                    }
                }
            }

            mainPanel.repaint();
        }
    }

    //Eento quando solta o botão
    @Override
    public void keyReleased(KeyEvent e) {
        //removi a exceçao porque quando soltava o botão acionava.

        //coloca a skin do boneeco parado ao soltar o botao.
        boneco.getBoneco().setIcon(new ImageIcon(boneco.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
    }

    public void mataBoneco(BlocoQuebra bl) {
        ArrayList<Boneco> bonecosARemover = new ArrayList<Boneco>();

        boolean direita = false;
        boolean esquerda = false;
        boolean cima = false;
        boolean baixo = false;

        //procura bonceo para esquerda e direita
        for (int nivel = 1; nivel < 29; nivel++) {
            int pxX = nivel * 7;
            for (Boneco b : listBonecos) {
                if (b.getX() == bl.getX() && b.getY() == bl.getY()) {
                    bonecosARemover.add(b);
                }
                boolean parede = false;
                // <editor-fold defaultstate="collapsed" desc="// ENCONTRA OS BLOCOS PRÓXIMOS À BOMBA------------------------">
                //encontra o bloco da direita
                if ((b.getX() == bl.getX() + pxX) && (b.getY() == bl.getY()) && !direita) {
                    for (BlocoFixo bf : listParedes) {
                        if ((bf.getX() == bl.getX() + pxX) && (bf.getY() == (bl.getY()))) {
                            parede = true;
                            direita = true;
                            break;
                        }
                    }
                    if (!parede) {
                        direita = true;
                        bonecosARemover.add(b);

//                        bonecoPlacar.getBoneco().setEnabled(false);
//                        System.out.println("Achou boneco à direita");
//                        Component c = mainPanel.getComponentAt(b.getX(), b.getY());
//                        mainPanel.remove(c);
                    }
                }
                //encontra o bloco da esquerda
                if ((b.getX() == bl.getX() - pxX) && (b.getY() == bl.getY()) && !esquerda) {
                    for (BlocoFixo bf : listParedes) {
                        if ((bf.getX() == bl.getX() - pxX) && (bf.getY() == (bl.getY()))) {
                            parede = true;
                            esquerda = true;
                            break;
                        }
                    }
                    if (!parede) {
                        esquerda = true;
                        bonecosARemover.add(b);
//                        System.out.println("Achou boneco à esquerda");
//                        Component c = mainPanel.getComponentAt(b.getX(), b.getY());
//                        mainPanel.remove(c);
                    }
                }
                // </editor-fold>
            }
        }



        //procura boneco para cima e para baixo
        for (int nivel = 1; nivel < 31; nivel++) {
            int pxY = nivel * 5;
            for (Boneco b : listBonecos) {
                boolean parede = false;
                //encontra o bloco de baixo
                // <editor-fold defaultstate="collapsed" desc="// ENCONTRA OS BLOCOS PRÓXIMOS À BOMBA------------------------">
                if (((b.getX() == bl.getX()) && (b.getY() == (bl.getY() + pxY))) && !baixo) {
                    for (BlocoFixo bf : listParedes) {
                        if ((bf.getX() == bl.getX()) && (bf.getY() == (bl.getY() + pxY))) {
                            parede = true;
                            baixo = true;
                            break;
                        }
                    }
                    if (!parede) {
                        baixo = true;
                        bonecosARemover.add(b);
//                        System.out.println("achou a baixo");
//                        Component c = mainPanel.getComponentAt(b.getX(), b.getY());
//                        mainPanel.remove(c);
                    }

                }
                //encontra o bloco de cima
                if (((b.getX() == bl.getX()) && (b.getY() == (bl.getY() - pxY))) && !cima) {
                    for (BlocoFixo bf : listParedes) {
                        if ((bf.getX() == bl.getX()) && (bf.getY() == (bl.getY() - pxY))) {
                            parede = true;
                            cima = true;
                            break;
                        }
                    }
                    if (!parede) {
                        cima = true;
                        bonecosARemover.add(b);
//                        System.out.println("achou a cima");
//                        Component c = mainPanel.getComponentAt(b.getX(), b.getY());
//                        mainPanel.remove(c);
                    }
                }
                // </editor-fold>
            }
        }
//        System.out.println("lista de bonecos a remover diferente de null: " + bonecosARemover.size());
        if (bonecosARemover != null && bonecosARemover.size() > 0) {
            Request request = new Request();
            request.setType(request.REQUEST_TYPE_DELETE_BONECO);
            request.setParam3(bonecosARemover);
            executeRequest(request);
        }
    }

    public void finalizaPartida(int resultado, ThreadClient t) {
        switch (resultado) {
            case 0: {
//                System.out.println("empate");
                this.setVisible(false);
                InterfaceGanhador it = new InterfaceGanhador(socket, outputStream, inputStream, null, usuarioPC);
                it.setVisible(true);
                t.setRefIG(it);
                t.setSocket(it.getSocket());
                t.setInputStream(it.getInputStream());
                t.setOutputStream(it.getOutputStream());
                break;
            }
            case 1: {

                this.setVisible(false);
                InterfaceGanhador it = new InterfaceGanhador(socket, outputStream, inputStream, listBonecos.get(0), usuarioPC);
                it.setVisible(true);
                t.setRefIG(it);
                t.setSocket(it.getSocket());
                t.setInputStream(it.getInputStream());
                t.setOutputStream(it.getOutputStream());
                break;
            }

        }
    }

    public void mudaFotoPlacar(ArrayList<Boneco> listBon) {
        for (Boneco boneco : listBon) {
            switch (boneco.getNumero()) {
                case 1: {
                    jLabelBonecoPlacarBranco.setEnabled(false);
                    break;
                }
                case 2: {
                    jLabelBonecoPlacarPreto.setEnabled(false);
                    break;
                }
                case 3: {
                    jLabelBonecoPlacarAzul.setEnabled(false);
                    break;
                }
                case 4: {
                    jLabelBonecoPlacarVermelho.setEnabled(false);
                    break;
                }
                case 5: {
                    jLabelBonecoPlacarVerde.setEnabled(false);
                    break;
                }
            }
        }

        Request request = new Request();
        request.setType(request.REQUEST_TYPE_VERIFICA_QTD_BONECOS);
        executeRequest(request);
    }

    // <editor-fold defaultstate="collapsed" desc="// METODOS PARA COLOCAR O FOGO------------------------">
    public ArrayList<BlocoQuebra> colocaFogo(BlocoQuebra bomba, ArrayList<Parede> paredesEncontradas, ArrayList<Parede> blocosEncontrados) {

        ArrayList<BlocoQuebra> Listfogo = new ArrayList<BlocoQuebra>();



        Parede paredeAux = null;

//        Parede blocoAux = null;

//        Parede paredeAux = null;
        Parede blocoAux = null;

//        boolean fogoCima = false;
//        boolean fogoBaixo = false;
//        boolean fogoDireita = false;
//        boolean fogoEsquerda = false;

        for (int nivel = 1; nivel < 4; nivel++) {
            int pxX = nivel * 49;
            int pxY = nivel * 40;
            for (BlocoQuebra linhaFogo : listLinhaDeFogo) {

                // <editor-fold defaultstate="collapsed" desc="// COLOCA FOGO A BAIXO------------------------">

                //coloca fogo a baixo
                if ((linhaFogo.getX() == bomba.getX()) && (linhaFogo.getY() == (bomba.getY() + pxY))) {
                    //verifica se exite parede
                    ///primeiro if  1 e 0
                    if (paredesEncontradas.size() > 0 && blocosEncontrados.size() < 1) {
                        //percorre as paredes encontradas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se existe alguma paarede a baixo
                            if (parede.isBaixo()) {
                                paredeAux = parede;
                            }
                        }
                        //verifica se parede foi encontrada a baixo
                        if (paredeAux != null) {
                            //verifica se a parede é mais a baixo
                            if (paredeAux.getBlocoFixo().getY() > (bomba.getY() + pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        paredeAux = null;
                    }

                    //segundo if 0 e 1
                    if (paredesEncontradas.size() < 1 && blocosEncontrados.size() > 0) {
                        //percorre os blocos encontradas
                        for (Parede bloco : blocosEncontrados) {
                            //verifica se existe algum bloco a baixo
                            if (bloco.isBaixo()) {
                                blocoAux = bloco;
                            }
                        }
                        //verifica se foi encontrado algum bloco a baixo
                        if (blocoAux != null) {
                            //verifica se o bloco é mais a baixo
                            if (blocoAux.getBlocoQuebra().getY() >= (bomba.getY() + pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        blocoAux = null;
                    }

                    //terceiro if 0 e 0
                    if (blocosEncontrados.size() < 1 && paredesEncontradas.size() < 1) {
                        BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                        Listfogo.add(fogo);
                    }

                    //quarto if 1 e 1
                    if (blocosEncontrados.size() > 0 && paredesEncontradas.size() > 0) {
                        //percorre as paredes encontadas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se alguma é a baixo
                            if (parede.isBaixo()) {
                                paredeAux = parede;
                            }
                        }
                        //percorre os blocos encontrados
                        for (Parede bloco : blocosEncontrados) {
                            //verifica se algum é a baixo
                            if (bloco.isBaixo()) {
                                blocoAux = bloco;
                            }
                        }
                        //primeiro if 1 e 0 
                        if (paredeAux != null && blocoAux == null) {
                            if (paredeAux.getBlocoFixo().getY() > (bomba.getY() + pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //segundo if 0 e 1
                        if (paredeAux == null && blocoAux != null) {
                            if (blocoAux.getBlocoQuebra().getY() >= (bomba.getY() + pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //terceiro if 0 e 0
                        if (paredeAux == null && blocoAux == null) {
                            //coloca fogo
                            BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                            Listfogo.add(fogo);
                        }
                        //quarto if 1 e 1
                        if (paredeAux != null && blocoAux != null) {
//                            System.out.println("entrou no if  testador baixo");

                            if (paredeAux.getBlocoFixo().getY() > blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getY() >= bomba.getY() + pxY) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }

                            if (paredeAux.getBlocoFixo().getY() < blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getY() >= bomba.getY() + pxY) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }
                        }
                        paredeAux = null;
                        blocoAux = null;
                    }
                }

                // </editor-fold> 

                // <editor-fold defaultstate="collapsed" desc="// COLOCA FOGO A CIMA------------------------">


                //coloca fogo a cima
                if ((linhaFogo.getX() == bomba.getX()) && (linhaFogo.getY() == (bomba.getY() - pxY))) {
                    //verifica se exite parede
                    //primeiro if 1 e 0
                    if (paredesEncontradas.size() > 0 && blocosEncontrados.size() < 1) {
                        //percorre as paredes encontradas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se existe parede a cima
                            if (parede.isCima()) {
                                paredeAux = parede;
                            }
                        }
                        //verifica se foi encontrado parede a cima
                        if (paredeAux != null) {
                            //verifica se a parede é mais a cima
                            if (paredeAux.getBlocoFixo().getY() < (bomba.getY() - pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        paredeAux = null;
                    }
                    //segundo if 0 e 1
                    if (paredesEncontradas.size() < 1 && blocosEncontrados.size() > 0) {
                        //percorre os blocos encontrados
                        for (Parede bloco : blocosEncontrados) {
                            // verifica se existe bloco a cima
                            if (bloco.isCima()) {
                                blocoAux = bloco;
                            }
                        }
                        //verifica se foi encontrado bloco a cima
                        if (blocoAux != null) {
                            if (blocoAux.getBlocoQuebra().getY() <= (bomba.getY() - pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        blocoAux = null;
                    }
                    //terceiro if 0 e 0
                    if (blocosEncontrados.size() < 1 && paredesEncontradas.size() < 1) {
                        BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                        Listfogo.add(fogo);
                    }
                    //quarto if 1 e 1
                    if (blocosEncontrados.size() > 0 && paredesEncontradas.size() > 0) {
                        //percorre as paredes encontradas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se existe parede a cima
                            if (parede.isCima()) {
                                paredeAux = parede;
                            }
                        }
                        //percorre os blocos encontrados
                        for (Parede bloco : blocosEncontrados) {
                            //verifica se existe bloco a cima
                            if (bloco.isCima()) {
                                blocoAux = bloco;
                            }
                        }
                        //promeiro if 1 e 0
                        if (paredeAux != null && blocoAux == null) {
                            //verifica se a parede é mais a cima
                            if (paredeAux.getBlocoFixo().getY() < (bomba.getY() - pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //segundo if 0 e 1
                        if (paredeAux == null && blocoAux != null) {
                            //verifica se o bloco é mais a cima
                            if (blocoAux.getBlocoQuebra().getY() <= (bomba.getY() - pxY)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //terceiro if 0 e 0
                        if (paredeAux == null && blocoAux == null) {
                            //coloca fogo
                            BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                            Listfogo.add(fogo);
                        }
                        //quarto if 1 e 1
                        if (paredeAux != null && blocoAux != null) {
                            //verifica se a parede é mais 
                            if (paredeAux.getBlocoFixo().getY() > blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getY() <= bomba.getY() - pxY) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }

                            if (paredeAux.getBlocoFixo().getY() < blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getY() <= bomba.getY() - pxY) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoVERTICAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }
                        }
                        paredeAux = null;
                        blocoAux = null;
                    }
                }


                // </editor-fold>

                // <editor-fold defaultstate="collapsed" desc="// COLOCA FOGO A DIREITA------------------------">

                //coloca fogo a direita
                if ((linhaFogo.getX() == (bomba.getX() + pxX)) && (linhaFogo.getY() == bomba.getY())) {
                    //verifica se exite parede
                    //primeiro if 1 e 0
                    if (paredesEncontradas.size() > 0 && blocosEncontrados.size() < 1) {
                        //percorre as paredes encontradas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se existe parede a direita
                            if (parede.isDireita()) {
                                paredeAux = parede;
                            }
                        }
                        //verifica se foi encontrada parede a direita
                        if (paredeAux != null) {
                            //verifica se a parede é mais a direita
                            if (paredeAux.getBlocoFixo().getX() > (bomba.getX() + pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        paredeAux = null;
                    }
                    //segundo if 0 e 1
                    if (paredesEncontradas.size() < 1 && blocosEncontrados.size() > 0) {
                        //percorre oos bloco encontrados
                        for (Parede bloco : blocosEncontrados) {
                            //verifica se existe bloco a direita
                            if (bloco.isDireita()) {
                                blocoAux = bloco;
                            }
                        }
                        //verifica se foi encontrado bloco a direita
                        if (blocoAux != null) {
                            //verifica se o bloco é mais a direita
                            if (blocoAux.getBlocoQuebra().getX() >= (bomba.getX() + pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        blocoAux = null;
                    }
                    //terceiro if 0 e 0
                    if (blocosEncontrados.size() < 1 && paredesEncontradas.size() < 1) {
                        BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                        Listfogo.add(fogo);
                    }
                    //quarto if 1 e 1
                    if (blocosEncontrados.size() > 0 && paredesEncontradas.size() > 0) {
                        //percorre as paredes encontradas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se existe parede a direita
                            if (parede.isDireita()) {
                                paredeAux = parede;
                            }
                        }
                        //percorre os blocos encontrados
                        for (Parede bloco : blocosEncontrados) {
                            //verifica se existe bloco a direita
                            if (bloco.isDireita()) {
                                blocoAux = bloco;
                            }
                        }
                        //primeiro if 1 e 0
                        if (paredeAux != null && blocoAux == null) {
                            //verifica se a parede é mais a direita
                            if (paredeAux.getBlocoFixo().getX() > (bomba.getX() + pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //segundo if 0 e 1
                        if (paredeAux == null && blocoAux != null) {
                            //verifica se o bloco é mais a direita
                            if (blocoAux.getBlocoQuebra().getX() >= (bomba.getX() + pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //terceiro if 0 e 0
                        if (paredeAux == null && blocoAux == null) {
                            //coloca fogo
                            BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                            Listfogo.add(fogo);
                        }
                        //quarto if 1 e 1
                        if (paredeAux != null && blocoAux != null) {
                            if (paredeAux.getBlocoFixo().getY() > blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getX() >= bomba.getX() + pxX) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }

                            if (paredeAux.getBlocoFixo().getY() < blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getX() >= bomba.getX() + pxX) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }
                        }
                        paredeAux = null;
                        blocoAux = null;
                    }
                }
                // </editor-fold>

                // <editor-fold defaultstate="collapsed" desc="// COLOCA FOGO A ESQUERDA------------------------">

                //coloca fogo a esquerda
                if ((linhaFogo.getX() == (bomba.getX() - pxX)) && (linhaFogo.getY() == bomba.getY())) {
                    //verifica se exite parede
                    //primeiro if 1 e 0
                    if (paredesEncontradas.size() > 0 && blocosEncontrados.size() < 1) {
                        //percorre as paredes encontradas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se existe parede a esquerda
                            if (parede.isEsquerda()) {
                                paredeAux = parede;
                            }
                        }
                        //verifica se encontrou parede a esquerda
                        if (paredeAux != null) {
                            //verifica se a parede é mais a esquerda
                            if (paredeAux.getBlocoFixo().getX() < (bomba.getX() - pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        paredeAux = null;
                    }
                    //segundo if 0 e 1
                    if (paredesEncontradas.size() < 1 && blocosEncontrados.size() > 0) {
                        //percorre os blocos encontrados
                        for (Parede bloco : blocosEncontrados) {
                            //verifica se existe bloco a esquerda
                            if (bloco.isEsquerda()) {
                                blocoAux = bloco;
                            }
                        }
                        //verifica se encontrou algum bloco a esquerda
                        if (blocoAux != null) {
                            //verifica se o bloco é mais a esquerda
                            if (blocoAux.getBlocoQuebra().getX() <= (bomba.getX() - pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        blocoAux = null;
                    }
                    //terceiro if 0 e 0
                    if (blocosEncontrados.size() < 1 && paredesEncontradas.size() < 1) {
                        BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                        Listfogo.add(fogo);
                    }
                    //quarto if 1 e 1
                    if (blocosEncontrados.size() > 0 && paredesEncontradas.size() > 0) {
                        //percorre as paredes encontradas
                        for (Parede parede : paredesEncontradas) {
                            //verifica se existe parede a esquerda
                            if (parede.isEsquerda()) {
                                paredeAux = parede;
                            }
                        }
                        //percorre os blocos encontrados
                        for (Parede bloco : blocosEncontrados) {
                            //verifica se existe bloco a esquerda
                            if (bloco.isEsquerda()) {
                                blocoAux = bloco;
                            }
                        }
                        //primeiro if 1 e 0
                        if (paredeAux != null && blocoAux == null) {
                            //verifica se a parede é mais a esquerda
                            if (paredeAux.getBlocoFixo().getX() < (bomba.getX() - pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //segundo if 0 e 1
                        if (paredeAux == null && blocoAux != null) {
                            //verifica se o bloco é mais a esquerda
                            if (blocoAux.getBlocoQuebra().getX() <= (bomba.getX() - pxX)) {
                                //coloca fogo
                                BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                Listfogo.add(fogo);
                            }
                        }
                        //terceiro if 0 e 0
                        if (paredeAux == null && blocoAux == null) {
                            //coloca fogo
                            BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                            Listfogo.add(fogo);
                        }
                        //quarto if 1 e 1
                        if (paredeAux != null && blocoAux != null) {
                            if (paredeAux.getBlocoFixo().getY() > blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getX() <= bomba.getX() - pxX) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }

                            if (paredeAux.getBlocoFixo().getY() < blocoAux.getBlocoQuebra().getY()) {
                                if (blocoAux.getBlocoQuebra().getX() <= bomba.getX() - pxX) {
                                    //coloca fogo
                                    BlocoQuebra fogo = insereFogoHORIZONTAL(linhaFogo);
                                    Listfogo.add(fogo);
                                }
                            }
                        }
                    }
                    paredeAux = null;
                    blocoAux = null;
                }
                // </editor-fold>
            }
        }
        BlocoQuebra fogo = new BlocoQuebra();
        fogo = bomba;
        fogo.setFogo(true);
        fogo.setImagem(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "fogoCENTRO.png");
        Listfogo.add(fogo);


        //colocar o fogo no banco

        for (BlocoQuebra b : Listfogo) {
            jLabelFogo = new JLabel(new ImageIcon(b.getImagem().replaceAll("server", "client").replaceAll("Delano", usuarioPC)));
            jLabelFogo.setLayout(null);
            jLabelFogo.setSize(48, 40);
            jLabelFogo.setLocation(b.getX(), b.getY());
            jLabelFogo.setName("FOGO");
            mainPanel.add(jLabelFogo);
            mainPanel.repaint();
        }
        return Listfogo;
    }

    public BlocoQuebra insereFogoHORIZONTAL(BlocoQuebra linhaFogo) {
        BlocoQuebra fogo = new BlocoQuebra();
        fogo = linhaFogo;
        fogo.setFogo(true);
        fogo.setX(linhaFogo.getX());
        fogo.setY(linhaFogo.getY());
        fogo.setImagem(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "fogoHORIZONTAL.png");
        return fogo;
    }

    public BlocoQuebra insereFogoVERTICAL(BlocoQuebra linhaFogo) {
        BlocoQuebra fogo = new BlocoQuebra();
        fogo = linhaFogo;
        fogo.setFogo(true);
        fogo.setX(linhaFogo.getX());
        fogo.setY(linhaFogo.getY());
        fogo.setImagem(System.getProperty("user.dir") + System.getProperty("file.separator") + "src" + System.getProperty("file.separator") + "images" + System.getProperty("file.separator") + "fogoVERTICAL.png");
        return fogo;
    }

    // </editor-fold>
    public void build() {
    }

    public void eventos() {
        // Eventos de Janela JFrame

        this.addWindowListener(
                new WindowAdapter() {
                    @Override
                    public void windowClosing(WindowEvent e) {
                        try {
                            ArrayList<Boneco> bonecosARemover = new ArrayList<Boneco>();
                            bonecosARemover.add(boneco);
                            Request request = new Request();
                            request.setType(request.REQUEST_TYPE_DELETE_BONECO);
                            request.setParam3(bonecosARemover);
                            executeRequest(request);
                            t.executando = false;
                            if (socket != null && !socket.isClosed()) {
                                socket.close();
                            }
                        } catch (Exception ex) {
                        }
                        System.exit(0);
                    }
                });

    }

    public void execute() {
        build();
        setVisible(true);
    }

    public synchronized Response executeRequest(Request request) {
        Response response = null;
        try {
            outputStream.writeObject(request);
            outputStream.flush();
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
        return response;
    }

    //Evennto quando solta o botão de uma letra 
    @Override
    public void keyTyped(KeyEvent e) {
        //apertando nas letras do teclado quando solta vem para esse metodo..
    }

    @Override
    public void windowOpened(WindowEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void windowClosing(WindowEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void windowClosed(WindowEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void windowIconified(WindowEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void windowDeiconified(WindowEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void windowActivated(WindowEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void windowDeactivated(WindowEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

//    public ArrayList<BlocoQuebra> getListDLugaresPossiveis() {
//        return listDLugaresPossiveis;
//    }
//
//    public void setListDLugaresPossiveis(ArrayList<BlocoQuebra> listDLugaresPossiveis) {
//        this.listDLugaresPossiveis = listDLugaresPossiveis;
//    }
//
    public ArrayList<BlocoQuebra> getListDLugaresNLivres() {
        return listDLugaresNLivres;
    }

    public void setListDLugaresNLivres(ArrayList<BlocoQuebra> listDLugaresNLivres) {
        this.listDLugaresNLivres = listDLugaresNLivres;
    }

    public ArrayList<BlocoFixo> getListParedes() {
        return listParedes;
    }

    public void setListParedes(ArrayList<BlocoFixo> listParedes) {
        this.listParedes = listParedes;
    }

    public ArrayList<Boneco> getListBonecos() {
        return listBonecos;
    }

    public void setListBonecos(ArrayList<Boneco> listBonecos) {
        this.listBonecos = listBonecos;
    }

    public Socket getSocket() {
        return socket;
    }

    public void setSocket(Socket socket) {
        this.socket = socket;
    }

    public ObjectInputStream getInputStream() {
        return inputStream;
    }

    public void setInputStream(ObjectInputStream inputStream) {
        this.inputStream = inputStream;
    }

    public ObjectOutputStream getOutputStream() {
        return outputStream;
    }

    public void setOutputStream(ObjectOutputStream outputStream) {
        this.outputStream = outputStream;
    }

    public JPanel getMainPanel() {
        return mainPanel;
    }

    public void setMainPanel(JPanel mainPanel) {
        this.mainPanel = mainPanel;
    }

    public Boneco getBoneco() {
        return boneco;
    }

    public void setBoneco(Boneco boneco) {
        this.boneco = boneco;
    }
}